Write a custom CUDA kernel that fuses depthwise convolution, pointwise convolution, batch normalization, and SiLU activation.

The original architecture performs:
1. Depthwise convolution: dw_output = depthwise_conv(input)
2. Pointwise convolution: pw_output = pointwise_conv(dw_output)
3. Batch normalization: bn_output = batch_norm(pw_output)
4. SiLU activation: silu_output = silu(bn_output)

You should fuse these four operations into a single CUDA kernel to avoid:
- Storing intermediate results to global memory
- Multiple memory transfers between operations

The SiLU activation function is defined as:
  silu(x) = x * sigmoid(x)

Considerations:
- Use appropriate grid and block dimensions to parallelize over batch size, channels, and spatial dimensions
- Implement efficient shared memory usage for convolution operations
- Handle batch normalization parameters properly
- Ensure numerical stability and precision

You are given the following architecture:

import torch
import torch.nn as nn

class Model(nn.Module):
    def __init__(self, in_channels=64, out_channels=128, kernel_size=3, groups=64):
        super(Model, self).__init__()
        self.depthwise = nn.Conv2d(in_channels, in_channels, kernel_size, 
                                 groups=groups, padding=kernel_size//2)
        self.pointwise = nn.Conv2d(in_channels, out_channels, 1)
        self.bn = nn.BatchNorm2d(out_channels)
    
    def forward(self, x):
        # Depthwise convolution
        x = self.depthwise(x)
        # Pointwise convolution
        x = self.pointwise(x)
        # Batch normalization
        x = self.bn(x)
        # SiLU activation
        return x * torch.sigmoid(x)